package com.example.project.constant;

import java.util.Map;
import java.util.ResourceBundle;

/**
 * 国际化工具类 - 对应 Ruby 的 I18n 功能
 */
public class I18n {
    
    private static ResourceBundle zhBundle;
    
    static {
        try {
            zhBundle = ResourceBundle.getBundle("locales.zh");
        } catch (Exception e) {
            // 使用默认值
        }
    }
    
    /**
     * 翻译方法
     */
    public static String t(String key) {
        return t(key, null);
    }
    
    public static String t(String key, Map<String, Object> params) {
        String value = getTranslation(key);
        if (value == null) {
            return key; // 返回键名作为默认值
        }
        
        if (params != null) {
            // 使用正则表达式进行全局替换，处理多次出现的相同参数
            for (Map.Entry<String, Object> entry : params.entrySet()) {
                String paramName = entry.getKey();
                String paramValue = entry.getValue() != null ? entry.getValue().toString() : "";
                // 转义特殊字符，避免正则表达式问题
                String escapedValue = paramValue.replace("\\", "\\\\")
                                               .replace("$", "\\$");
                // 使用正则表达式进行全局替换
                value = value.replaceAll(java.util.regex.Pattern.quote("%{" + paramName + "}"), 
                                       java.util.regex.Matcher.quoteReplacement(escapedValue));
            }
        }
        
        return value;
    }
    
    private static String getTranslation(String key) {
        if (zhBundle != null && zhBundle.containsKey(key)) {
            return zhBundle.getString(key);
        }
        
        // 硬编码一些常用翻译
        Map<String, String> commonTranslations = Map.ofEntries(
            Map.entry("field_status", "状态"),
            Map.entry("field_start_date", "开始日期"),
            Map.entry("field_due_date", "计划完成日期"),
            Map.entry("field_assigned_to", "指派给"),
            Map.entry("field_recipient", "领取人"),
            Map.entry("field_priority", "优先级"),
            Map.entry("field_project", "项目"),
            Map.entry("field_subject", "主题"),
            Map.entry("button_add", "新增"),
            Map.entry("label_total", "合计"),
            Map.entry("label_x_open_issues_abbr", "%{count} 打开"),
            Map.entry("label_x_closed_issues_abbr", "%{count} 已关闭"),
            Map.entry("text_are_you_sure", "您确定？"),
            Map.entry("label_delete_link_to_subtask", "删除关联"),
            // 添加journal相关的翻译
            Map.entry("text_journal_changed_no_detail", "<strong>%{label}</strong> 已更新。"),
            Map.entry("text_journal_changed", "<strong>%{label}</strong> 从 %{old} 变更为 %{new}"),
            Map.entry("text_journal_set_to", "<strong>%{label}</strong> 被设置为 %{value}"),
            Map.entry("text_journal_deleted", "<strong>%{label}</strong> 已删除 (<del><i>%{old}</i></del>)"),
            Map.entry("text_journal_added", "<strong>%{label}</strong> %{value} 已添加")
        );
        
        return commonTranslations.get(key);
    }
    
    /**
     * 条件翻译 - 根据参数值选择不同的翻译
     * @param key 翻译键的基础名称
     * @param conditionParam 条件参数名
     * @param conditionValue 条件参数值
     * @param otherParams 其他参数
     * @return 根据条件选择的翻译结果
     */
    public static String tConditional(String key, String conditionParam, Object conditionValue, Map<String, Object> otherParams) {
        // 构建完整的翻译键名
        String fullKey = key + "_" + conditionParam + "_" + conditionValue.toString();
        
        // 首先尝试完整的条件键
        if (zhBundle != null && zhBundle.containsKey(fullKey)) {
            return t(fullKey, otherParams);
        }
        
        // 检查硬编码翻译
        Map<String, String> commonTranslations = Map.ofEntries(
            Map.entry("field_status", "状态"),
            Map.entry("field_start_date", "开始日期"),
            Map.entry("field_due_date", "计划完成日期"),
            Map.entry("field_assigned_to", "指派给"),
            Map.entry("field_recipient", "领取人"),
            Map.entry("field_priority", "优先级"),
            Map.entry("field_project", "项目"),
            Map.entry("field_subject", "主题"),
            Map.entry("button_add", "新增"),
            Map.entry("label_total", "合计"),
            Map.entry("label_x_open_issues_abbr", "%{count} 打开"),
            Map.entry("label_x_closed_issues_abbr", "%{count} 已关闭"),
            Map.entry("text_are_you_sure", "您确定？"),
            Map.entry("label_delete_link_to_subtask", "删除关联"),
            // 添加journal相关的翻译
            Map.entry("text_journal_changed_no_detail", "%{label} 已更新。"),
            Map.entry("text_journal_changed", "%{label} 从 %{old} 变更为 %{new}"),
            Map.entry("text_journal_set_to", "%{label} 被设置为 %{value}"),
            Map.entry("text_journal_deleted", "%{label} 已删除 (%{old})"),
            Map.entry("text_journal_added", "%{label} %{value} 已添加")
        );
        
        if (commonTranslations.containsKey(fullKey)) {
            return t(fullKey, otherParams);
        }
        
        // 如果找不到，尝试基础键
        return t(key, otherParams);
    }
    
    /**
     * 复数形式翻译 - 根据数量选择单数或复数形式
     * @param key 翻译键的基础名称
     * @param count 数量
     * @param params 其他参数
     * @return 根据数量选择的翻译结果
     */
    public static String tPlural(String key, int count, Map<String, Object> params) {
        // 构建复数形式的键名
        String pluralKey = key + "_plural";
        String singularKey = key + "_one";
        
        if (count == 1) {
            // 单数形式
            if (zhBundle != null && zhBundle.containsKey(singularKey)) {
                if (params == null) {
                    params = new java.util.HashMap<>();
                }
                params.put("count", count);
                return t(singularKey, params);
            }
        } else {
            // 复数形式
            if (zhBundle != null && zhBundle.containsKey(pluralKey)) {
                if (params == null) {
                    params = new java.util.HashMap<>();
                }
                params.put("count", count);
                return t(pluralKey, params);
            }
        }
        
        // 默认处理
        if (params == null) {
            params = new java.util.HashMap<>();
        }
        params.put("count", count);
        return t(key, params);
    }
    
    /**
     * 枚举值翻译 - 根据枚举值选择翻译
     * @param key 翻译键的基础名称
     * @param enumValue 枚举值
     * @param params 其他参数
     * @return 枚举值对应的翻译
     */
    public static String tEnum(String key, Enum<?> enumValue, Map<String, Object> params) {
        String enumKey = key + "_" + enumValue.name().toLowerCase();
        return t(enumKey, params);
    }
    
    /**
     * 布尔值翻译 - 根据布尔值选择翻译
     * @param key 翻译键的基础名称
     * @param boolValue 布尔值
     * @param params 其他参数
     * @return 布尔值对应的翻译
     */
    public static String tBoolean(String key, boolean boolValue, Map<String, Object> params) {
        String boolKey = key + "_" + (boolValue ? "true" : "false");
        return t(boolKey, params);
    }
}